package y2016.date1019.am.文件操作工具类;

import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Calendar;

public class FileUtil {

    private static final String TAG = FileUtil.class.getSimpleName();

    /**
     * 根据URL获取文件名
     *
     * @param url URL
     * @return 文件名
     */
    public static String getFileNameFromUrl(String url) {
        if (url.indexOf("/") != -1)
            return url.substring(url.lastIndexOf("/")).replace("/", "");
        else
            return url;
    }

    /**
     * TODO<根据路径删除指定的目录或文件，无论存在与否>
     *
     * @return boolean
     */
    public static boolean deleteFolder(String filePath) {
        File file = new File(filePath);
        if (!file.exists()) {
            return false;
        } else {
            if (file.isFile()) {
                // 为文件时调用删除文件方法
                return deleteFile(filePath);
            } else {
                // 为目录时调用删除目录方法
                return deleteDir(filePath);
            }
        }
    }

    /**
     * TODO<创建文件夹>
     *
     * @return File
     */
    public static File createDir(String path) {
        File dir = new File(path);
        if (!isExist(dir)) {
            dir.mkdirs();
        }
        return dir;
    }

    /**
     * TODO<删除文件夹及文件夹下的文件>
     *
     * @return boolean
     */
    public static boolean deleteDir(String dirPath) {
        boolean flag = false;
        // 如果dirPath不以文件分隔符结尾，自动添加文件分隔符
        if (!dirPath.endsWith(File.separator)) {
            dirPath = dirPath + File.separator;
        }
        File dirFile = new File(dirPath);

        if (!dirFile.exists() || !dirFile.isDirectory()) {
            return false;
        }

        flag = true;
        File[] files = dirFile.listFiles();
        // 遍历删除文件夹下的所有文件(包括子目录)
        for (int i = 0; i < files.length; i++) {
            if (files[i].isFile()) {
                // 删除子文件
                flag = deleteFile(files[i].getAbsolutePath());
                if (!flag)
                    break;
            } else {
                // 删除子目录
                flag = deleteDir(files[i].getAbsolutePath());
                if (!flag)
                    break;
            }
        }
        if (!flag)
            return false;
        // 删除当前空目录
        return dirFile.delete();
    }

    /**
     * TODO<获取指定目录下文件的个数>
     *
     * @return int
     */
    public static int getFileCount(String dirPath) {
        int count = 0;

        // 如果dirPath不以文件分隔符结尾，自动添加文件分隔符
        if (!dirPath.endsWith(File.separator)) {
            dirPath = dirPath + File.separator;
        }
        File dirFile = new File(dirPath);

        if (!dirFile.exists() || !dirFile.isDirectory()) {
            return count;
        }

        // 获取该目录下所有的子项文件(文件、子目录)
        File[] files = dirFile.listFiles();
        // 遍历删除文件夹下的所有文件(包括子目录)
        for (int i = 0; i < files.length; i++) {
            if (files[i].isFile()) {
                // 删除子文件
                count += 1;
            }
        }

        return count;
    }

    /**
     * TODO<创建文件>
     *
     * @return File
     */
    public static File createFile(String path, String fileName) {
        File file = new File(createDir(path), fileName);
        if (!isExist(file)) {
            try {
                file.createNewFile();
            } catch (IOException e) {
                //				Log.e(TAG, "创建文件出错：" + e.toString());
                e.printStackTrace();
            }
        }
        return file;
    }

    /**
     * TODO<删除指定地址的文件夹>
     *
     * @return void
     */
    public static boolean deleteFile(String filePath) {
        File file = new File(filePath);
        if (file.isFile() && isExist(file))
            return file.delete();
        return false;
    }

    private int succssNum = 0;
    private int failNum = 0;

    /**
     * 复制文件或文件夹
     *
     * @param sourcePath 资源文件路径
     * @param targetPath 目标文件路径
     *                   <p> 如：复制 sdCard0/a/wo 到 sdCard1/,自动在sdCard1/路径下创建wo文件夹，并复制其中所有子文件和子文件夹的内容
     */
    public void copyFileFloder(String sourcePath, String targetPath) {
        File sourceFile = new File(sourcePath);
        File targetFile = new File(targetPath, sourceFile.getName());
        succssNum = 0;
        failNum = 0;
        if (sourceFile.isDirectory()) {
            copyFolder(sourceFile, targetFile);
        } else {
            copyFile(sourceFile, targetFile);
        }
    }

    /**
     * 复制一个目录及其子目录、文件到另外一个目录
     *
     * @param source 资源文件
     * @param target 目标文件
     */
    public void copyFolder(File source, File target) {
        if (source.isDirectory()) {
            if (!target.exists()) {
                target.mkdir();
            }
            String files[] = source.list();
            for (String file : files) {
                File srcFile = new File(source, file);
                File destFile = new File(target, file);
                // 递归复制
                copyFolder(srcFile, destFile);
            }

        } else {//如果不是目录，是一个文件。

            copyFile(source, target);
        }
    }

    /**
     * 复制单个的文件
     *
     * @param sourcefile 资源文件
     * @param targetFile 目标文件
     * @return 复制成功true，失败false
     */
    private boolean copyFile(File sourcefile, File targetFile) {
        if (targetFile.exists()) {
            System.out.println(targetFile.getAbsolutePath() + "已经存在");
            return false;
        }
        System.out.println("复制到： " + targetFile.getAbsolutePath());
        InputStream is = null;
        BufferedInputStream bis = null;

        OutputStream os = null;
        BufferedOutputStream bos = null;

        try {
            is = new FileInputStream(sourcefile);
            bis = new BufferedInputStream(is);

            os = new FileOutputStream(targetFile);
            bos = new BufferedOutputStream(os);

            byte[] b = new byte[1024 * 5];
            int len = 0;

            while ((len = bis.read(b)) != -1) {
                bos.write(b, 0, len);
            }
            bos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bos != null) {
                    bos.close();
                }
                if (os != null) {
                    os.close();
                }
                if (bis != null) {
                    bis.close();
                }
                if (is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (sourcefile.length() == targetFile.length()) {
            System.out.println(sourcefile.getName() + "复制成功");
            succssNum++;
            return true;
        } else {
            System.out.println("操作失败");
            boolean bool = targetFile.delete();
            if (bool) {
                System.out.println("成功清除");
            } else {
                System.out.println("清除失败");
            }
            failNum++;
            return false;
        }

    }

    public static void writeStringBufferToPath(StringBuffer sb, String path) {
        writeStringToPath(sb.toString(), path);
    }

    public static void writeStringBuilderToPath(StringBuilder sb, String path) {
        writeStringToPath(sb.toString(), path);
    }

    /**
     * @param str  字符串
     * @param path 绝对路径
     *             默认覆盖
     */
    public static void writeStringToPath(String str, String path) {
        writeBytesToPath(str.getBytes(), path);
    }

    public static void writeStringToFile(String str, File file) {
        writeBytesToFile(str.getBytes(), file);
    }

    /**
     * @param b
     * @param path 绝对路径
     *             当文件相同默认覆盖
     *             注意直接将byte数组存到文件中，可能会产生一些特殊符号，这是由于byte[]装载的数字对应于ASCII码
     */
    public static void writeBytesToPath(byte[] b, String path) {
        writeBytesToFile(b, new File(path), true);
    }

    /**
     * @param b
     * @param file 当文件相同默认覆盖
     */
    public static void writeBytesToFile(byte[] b, File file) {
        writeBytesToFile(b, file, true);
    }

    /**
     * @param b
     * @param file
     * @param mode 模式，true,覆盖
     */
    public static void writeBytesToFile(byte[] b, File file, boolean mode) {
        file.getParentFile().mkdirs();
        if (file.exists()) {
            if (file.isDirectory()) {
                System.err.println("文件是个目录");
                return;
            }
            if (mode) {
                System.out.println("开始更新...");
            } else {
                System.out.println("文件已经存在...");
                return;
            }
        }
        OutputStream os = null;
        BufferedOutputStream bos = null;
        ByteArrayOutputStream bao = null;
        try {
            os = new FileOutputStream(file);
            bos = new BufferedOutputStream(os);

            bos.write(b);
            bos.flush();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bos.close();
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static String getString(String path) {
        return new String(getBytes(path));
    }

    /**
     * 获得指定文件的byte数组
     */
    public static byte[] getBytes(String path) {
        byte[] buffer = null;
        try {
            File file = new File(path);
            if (!file.exists()) {
                System.err.println("文件不存在");
                return null;
            }
            FileInputStream fis = new FileInputStream(file);
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            byte[] b = new byte[1024];
            int n;
            while ((n = fis.read(b)) != -1) {
                bos.write(b, 0, n);
            }
            fis.close();
            bos.close();
            buffer = bos.toByteArray();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return buffer;
    }

    /**
     * TODO<判断File对象所指的目录或文件是否存在>
     *
     * @return boolean
     */
    public static boolean isExist(File file) {
        return file.exists();
    }

    // java的file类没有读取文件创建时间的api
    //  public static String getCreateTime( File file){
    //		return null;
    //  }

    /**
     * 读取文件最后修改时间的方法
     *
     * @return 形如：yyyy-MM-dd HH:mm:ss的时间
     */
    public static String getLastModifiedTime(File file) {
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        long time = file.lastModified();//1970年到文件修改时间的毫秒数
        calendar.setTimeInMillis(time);
        return formatter.format(calendar.getTime());
    }

}

